package group;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.ListIterator;

import role.Role;
import role.RoleFactory;
import student.Student;

/*
 * ==UML
 * Bei Änderung an Mitgliederzahl, nicht Vergessen, curMembers mitzuführen!
 * 
 */
public class UserGroup extends Group
{
	private ArrayList<Role> roles = new ArrayList<Role>();
	private int maxSize, curSize = 0;

	public ArrayList<Role> getRoles()
	{
		return roles;
	}

	public UserGroup(int maxMembers, String name)
	{
		super(name);
		this.maxSize = maxMembers;
		for (int i = 0; i < maxMembers; i++) // F�gt die Default-Rollen hinzu
		{
			roles.add(RoleFactory.getStandardRole());
		}
	}

	/**
	 * Gibt eine ArrayList mit allen Gruppenmitgliedern zurück
	 * 
	 * @return ArrayList mit allen Gruppenmitgliedern
	 */
	public ArrayList<Student> getMembers()
	{
		ArrayList<Student> member = new ArrayList<Student>();
		Iterator<Role> iter_rollen = roles.iterator();
		while (iter_rollen.hasNext())
		{
			Role role = iter_rollen.next();
			if (role.getStudent() != null)
			{
				member.add(role.getStudent());
			}
		}
		return member;
	}

	/**
	 * Editiert die erste Rolle, die gleich role ist so, dass newName der neue
	 * Name und newComment der neue Kommentar ist
	 * 
	 * @param role
	 *            Zu bearbeitende Rolle
	 * @param newName
	 *            Neuer Name
	 * @param newComment
	 *            Neuer Kommentar
	 */
	public void setRole(Role role, String newName, String newComment)
	{
		ListIterator<Role> it = roles.listIterator();
		while (it.hasNext())
		{
			if (it.next() == role)
			{
				it.previous().setName(newName);
				it.next().setComment(newComment);
			}
		}
	}

	/**
	 * 
	 * @param student
	 * @return true: falls Student in Gruppe<br>
	 *         false: sonst
	 */
	public boolean hasStudent(Student student)
	{
		// Hierzu vielleicht noch nötig, Vergleichsmethode beim Studenten zu
		// ändern
		ListIterator<Role> it = roles.listIterator();
		while (it.hasNext())
		{
			if (it.next().getStudent() == student)
				return true;
		}
		return false;
	}

	/**
	 * Fügt den Studenten in den Nächsten freien Platz ein, falls vorhanden
	 * 
	 * @param student
	 */
	public void addStudent(Student student) // Vielleicht noch
											// Boolean-Rückgabewerte
	{
		ListIterator<Role> it = roles.listIterator();
		while (it.hasNext())
		{
			if (it.next().getStudent() == null)
			{
				it.previous().setStudent(student);
				curSize++;
				break;
			}
		}
	}

	/**
	 * Erhöht die Größe um 1 und fügt eine neue Standardrolle ein.
	 */
	public void incrementSize()
	{
		maxSize++;
		roles.add(new Role());
	}

	/**
	 * Verringert die Größe um 1, wenn es mindestens eine leere Standardrolle
	 * gibt.
	 * 
	 * @return true: wenn verringert<br>
	 *         false: keine leere Standardrolle
	 */
	public boolean decrementSize()
	{
		if (this.hasSpace())
		{
			ListIterator<Role> it = roles.listIterator();
			Role role;
			while (it.hasNext())
			{
				role = it.next();
				if ((role.hasStudent() == false) && (role.getName() == null))
				{
					maxSize--;
					it.remove();
					return true;
				}
			}
		}
		return false;
	}

	public boolean hasSpace()
	{
		return (maxSize > curSize);
	}

	@Override
	public String getName()
	{
		return super.getName();
	}

	@Override
	public void setName(String name)
	{
		super.setName(name);
	}

	public int getMaxSize()
	{
		return maxSize;
	}

	public void setMaxSize(int newMaxSize)
	{
		this.maxSize = newMaxSize;
	}

	public int getCurrentSize()
	{
		return curSize;
	}

	public boolean removeStudent(Student student)
	{
		ListIterator<Role> it = roles.listIterator();
		while (it.hasNext())
		{
			if (it.next().getStudent() == student)
			{
				it.previous().removeStudent();
				curSize--;
				return true;
			}
		}
		return false;
	}
}
